var _n40;
var cc__extends = __extends;
var cc__decorate = __decorate;
var cc__importDefault = __importDefault;
Object.defineProperty(exports, "__esModule", {
  value: true
});
var cc__decorator = cc._decorator;
var ccp_ccclass = cc__decorator.ccclass;
var ccp_property = cc__decorator.property;
var $1$Rope = require("Rope");
var u = cc__importDefault($1$Rope);
var $1$ScrewGameConfig = require("ScrewGameConfig");
var p = cc__importDefault($1$ScrewGameConfig);
var $1$Target = require("Target");
var d = cc__importDefault($1$Target);
var $1$TmpNodeManager = require("TmpNodeManager");
var h = cc__importDefault($1$TmpNodeManager);
var $1$TmpRope = require("TmpRope");
var f = cc__importDefault($1$TmpRope);
var $1$PaintBoard = require("zqcc_PaintBoard");
var y = cc__importDefault($1$PaintBoard);
var $1$RopeTexture = require("RopeTexture");
var g = cc__importDefault($1$RopeTexture);
var $zqcc_OverallSystem = require("zqcc_OverallSystem");
function m(t) {
  var e = t.reduce(function (t, e) {
    t[e] = (t[e] || 0) + 1;
    return t;
  }, {});
  var o = Math.max.apply(Math, Object.values(e));
  return Object.keys(e).filter(function (t) {
    return e[parseInt(t)] === o;
  }).map(Number);
}
function _(t, e, o) {
  var n = t[e];
  t[e] = t[o];
  t[o] = n;
}
var def_TargetMgr = function (t) {
  function _ctor() {
    // 初始化实例
    let instance = null !== t && t.apply(this, arguments) || this;

    // 设置初始值
    instance.unlockCount = 2;      // 解锁计数
    instance.easyCount = 0;        // 简单计数
    instance.targetsNode = null;   // 目标节点
    instance.levelRoot = null;     // 关卡根节点
    instance.targetPrefab = null;   // 目标预制体
    instance.ropePrefab = null;     // 绳子预制体
    instance.tmpNodeMgr = null;     // 临时节点管理器
    instance.paintBoard = null;      // 画板
    instance.progressBar = null;     // 进度条
    instance.progressLabel = null;   // 进度标签
    instance.feibiao = null;         // 飞标
    instance.data = [];              // 数据数组
    instance.targets = [];           // 目标数组
    instance.totalTargetCount = 0;   // 目标总计数
    instance.targetPos = [];         // 目标位置数组

    // 返回初始化的实例
    return instance;
  }
  cc__extends(_ctor, t);
  _ctor.prototype.start = function () {
    cc.game.on("btn_add_tmp", this.onUnlockTmp, this);
    cc.game.on("remove_board", this.onRemoveBoard, this);
    cc.game.on("btn_clear_tmp", this.onClearTmp, this);
    cc.game.on("unlock_2", this.onUnlock, this);
    cc.game.on("unlock_1", this.onUnlock, this);
    this.progressBar.progress = 0.01;
    this.feibiao = this.node.parent.getComponent("Feibiao");
  };
  _ctor.prototype.setData = function (t, e) {
    // 将传入的数据赋值给this.data
    this.data = t;

    // 设置目标的总计数
    this.totalTargetCount = t.length;

    // 输出当前数据以便于调试
    cc.log("Current target data in targetMgr:", this.data);

    // 初始化目标数组
    this.targets = [];

    // 调用初始化目标的方法
    this.initTarget();

    // 设置游戏状态
    this.gamePlay = e;
  };
  _ctor.prototype.getProgress = function () {
    return (this.totalTargetCount - this.data.length) / this.totalTargetCount;
  };
  _ctor.prototype.initTarget = function () {
    // 遍历目标节点的子节点并存储位置
    for (let index = 0; index < this.targetsNode.children.length; index++) {
      const position = this.targetsNode.children[index].position; // 获取当前子节点的位置
      this.targetPos[index] = position; // 存储目标位置
    }

    // 根据解锁计数生成目标
    for (let i = 0; i < this.unlockCount; i++) {
      const nextTarget = this.getNextTarget(); // 获取下一个目标

      if (nextTarget >= 0) {
        this.handleTargetGeneration(i, nextTarget); // 生成目标
      } else {
        cc.log("所有目标已经出完"); // 输出消息表示目标已生成完毕
      }
    }
  };
  _ctor.prototype.handleTargetGeneration = function (t, e) {
    // 获取目标位置
    const targetPosition = this.targetPos[t];

    // 实例化目标预制体
    const targetInstance = cc.instantiate(this.targetPrefab);

    // 设置目标实例的位置
    targetInstance.position = cc.v3(targetPosition.x - 750, targetPosition.y, 0);

    // 将目标实例添加到目标节点中
    targetInstance.parent = this.targetsNode;
    targetInstance.zIndex = 10 - t; // 设置绘制顺序

    // 获取目标实例的组件
    const targetComponent = targetInstance.getComponent(d.default);

    // 初始化目标组件类型
    targetComponent.initWithType(e);
    targetComponent.posIndex = t; // 设置位置索引

    // 将目标组件添加到目标数组中
    this.targets.push(targetComponent);

    // 调用动画效果，处理目标进入
    this.animateTargetEntry(targetInstance, targetPosition, targetComponent);
  };
  _ctor.prototype.animateTargetEntry = function (t, e, o) {
    const context = this; // 保存当前上下文

    // 创建平移动画
    cc.tween(t)
      .to(0.3, {
        position: cc.v3(e.x, e.y, 0) // 设置目标位置
      }, {
        easing: "quadOut" // 设置缓动类型
      })
      .call(() => {
        // 动画完成后的回调
        o.state = p.default.TargetState.Ready; // 设置目标状态为准备状态
        context.checkTemporarySlot(); // 检查临时插槽
        context.checkGameOver("handleTargetGeneration"); // 检查游戏是否结束
      })
      .start(); // 开始动画
  };
  _ctor.prototype.handleRopeAnimation = function (t, e) {
    // 定义目标移动的函数
    const moveToTarget = (index) => {
      cc.tween(e.node)
        .delay(0.05 * index) // 设置延迟
        .call(() => {
          // 移动到目标位置
          e.moveToTarget(t[index].x, t[index].y, 0.05);
        })
        .start(); // 开始动画
    };

    // 遍历目标位置数组并执行移动
    for (let idx = 0; idx < t.length; idx++) {
      moveToTarget(idx); // 调用移动函数
    }
  };
  _ctor.prototype.findMatchingTarget = function (t, e) {
    // 确保e已定义，默认值为true
    if (undefined === e) {
      e = true;
    }

    // 查找符合条件的目标
    const target = this.targets.find((target) => {
      return target.targetCount > 0
        && target.type === t.type
        && (!e || target.state === p.default.TargetState.Ready);
    });

    // 返回找到的目标或null
    return target || null;
  };
  _ctor.prototype.fillOrder = function (t, e, o) {
    const context = this; // 保存当前上下文

    // 确保o已定义，默认值为20
    if (undefined === o) {
      o = 20;
    }

    // 获取e的子对象和完成状态
    const subObject = e.sub();
    const isFinished = e.isFinish();

    // 执行动作动画
    this.operateObjAnimation(t, subObject, () => {
      // 动画完成后的回调
      if (isFinished) {
        context.checkTargetFinish(e); // 检查目标是否完成
      } else {
        context.checkTemporarySlot(); // 检查临时插槽
      }
    }, o);
  };
  _ctor.prototype.createRopeNode = function (t, e, o) {
    // 确保o已定义，默认值为20
    if (undefined === o) {
      o = 20;
    }

    // 实例化绳子预制体并添加到关卡根节点
    const ropeInstance = cc.instantiate(this.ropePrefab);
    this.levelRoot.addChild(ropeInstance, cc.macro.MAX_ZINDEX);

    // 获取绳子的组件并设置属性
    const ropeComponent = ropeInstance.getComponent(g.default);
    ropeComponent.type = e; // 设置绳子类型
    ropeComponent.amplitude = o; // 设置振幅
    ropeComponent.updateEndPoint(0, 0); // 更新终点

    // 将绳子的位置转换到节点空间并设置
    const nodeSpacePosition = this.convertToNodeSpaceAR(t, ropeInstance.parent);
    ropeInstance.position = nodeSpacePosition;

    // 返回绳子的组件
    return ropeComponent;
  };
  _ctor.prototype.convertToNodeSpaceAR = function (t, e) {
    var o = t.parent.convertToWorldSpaceAR(t.position);
    return e.convertToNodeSpaceAR(o);
  };
  _ctor.prototype.checkTargetFinish = function (t) {
    const context = this; // 保存当前上下文
    cc.log("checkTargetFinish", t.targetCount); // 输出目标计数

    // 检查目标是否完成
    if (t.isFinish()) {
      cc.log("finish");

      // 从目标列表中移除已完成的目标
      this.targets = this.targets.filter((target) => target !== t);

      // 创建绳子节点
      const ropeNode = this.createRopeNode(t.node, t.type);

      // 处理绘制颜色的回调
      const paintResult = this.paintBoard.zqcc_drawWithColor(t.type, (pos, isComplete) => {
        const cellPosition = context.paintBoard.zqcc_getCellPosition(pos.x, pos.y);
        const worldPosition = context.paintBoard.zqcc_gridContainer.convertToWorldSpaceAR(cellPosition);
        const localPosition = ropeNode.node.convertToNodeSpaceAR(worldPosition);

        // 移动绳子到目标位置
        ropeNode.moveToTarget(localPosition.x, localPosition.y, 0.05);
        $zqcc_OverallSystem.mgrs().soundMgr.playEffect("merge_4", "Feibiao", false, 0.05);
        $zqcc_OverallSystem.sers().platformSrv.platformApi.vibrateShort(false);

        // 如果绘制已完成，销毁绳子并处理后续逻辑
        if (isComplete) {
          ropeNode.destroyByReset();
          if (isFinished) {
            context.scheduleOnce(() => {
              context.feibiao.pass(); // 处理飞标通过逻辑
            }, 0.5);
          }
        }
      });

      const duration = paintResult.duration; // 获取绘制的持续时间
      const isFinished = paintResult.isFinished; // 检查绘制是否完成
      cc.log("isFinish", isFinished); // 输出绘制完成状态

      // 更新进度条和进度标签
      this.progressBar.progress = this.getProgress();
      this.progressLabel.string = (100 * this.getProgress()).toFixed(0) + "%";

      // 播放完成动画
      t.showFinishAnimation(duration, () => {
        cc.tween(t.node)
          .by(0.3, {
            position: cc.v3(-750, 0, 0) // 设置移动位置
          }, {
            easing: "quadIn" // 设置缓动效果
          })
          .call(() => {
            // 根据条件调整easyCount和目标
            if (context.easyCount > 0) {
              context.easyCount--;
              context.setTargetWithTopBoard();
            } else if (context.getProgress() < 0.5) {
              context.setTargetWithTopBoard(1);
            } else {
              context.getProgress() < 0.7 && context.setTargetWithTopBoard(2);
            }

            // 获取下一个目标并处理生成
            const nextTarget = context.getNextTarget();
            if (nextTarget >= 0) {
              $zqcc_OverallSystem.mgrs().soundMgr.playSound("镖靶更换2");
              context.handleTargetGeneration(t.posIndex, nextTarget);
            } else {
              context.checkGameOver("checkTargetFinish");
              cc.log("所有目标已经出完");
            }
          })
          .removeSelf() // 移除动画对象
          .start(); // 开始动画
      });
    }
  };
  _ctor.prototype.checkTemporarySlot = function () {
    // 遍历临时节点管理器中的活动槽
    for (let index = 0; index < this.tmpNodeMgr.activeSlotCount; index++) {
      const temporaryNode = this.tmpNodeMgr.tmpContents[index]; // 获取当前临时节点

      // 检查临时节点是否存在且未动画化
      if (temporaryNode) {
        const matchingTarget = this.findMatchingTarget(temporaryNode);

        if (!temporaryNode.isAnimated && matchingTarget) {
          this.tmpNodeMgr.tmpContents[index] = null; // 清空临时内容
          return this.fillOrder(temporaryNode, matchingTarget, 5); // 填充顺序
        }
      }
    }

    // 从隐藏的临时节点中向后遍历
    for (let i = this.tmpNodeMgr.hideTmpNode.children.length - 1; i >= 0; i--) {
      const hiddenNode = this.tmpNodeMgr.hideTmpNode.children[i]; // 获取隐藏节点
      const component = hiddenNode.getComponent(f.default); // 获取组件

      const target = this.findMatchingTarget(component); // 查找匹配目标
      if (target) {
        return this.fillOrder(component, target, 5); // 填充顺序
      }
    }
  };
  _ctor.prototype.isAnyMatched = function () {
    // 遍历临时节点管理器中的活动槽
    for (let index = 0; index < this.tmpNodeMgr.activeSlotCount; index++) {
      const temporaryNode = this.tmpNodeMgr.tmpContents[index]; // 获取当前临时内容

      // 如果临时节点存在且找到匹配目标
      if (temporaryNode && (matchingTarget = this.findMatchingTarget(temporaryNode, false))) {
        cc.log("isAnyMatched1", matchingTarget.type, temporaryNode.type); // 记录匹配信息
        return matchingTarget; // 返回匹配目标
      }
    }

    // 从隐藏的临时节点中向后遍历
    for (let index = this.tmpNodeMgr.hideTmpNode.children.length - 1; index >= 0; index--) {
      const hiddenNode = this.tmpNodeMgr.hideTmpNode.children[index]; // 获取隐藏节点
      const component = hiddenNode.getComponent(f.default); // 获取组件

      // 查找匹配目标
      if (matchingTarget = this.findMatchingTarget(component, false)) {
        cc.log("isAnyMatched2", matchingTarget.type, component.type); // 记录匹配信息
        return matchingTarget; // 返回匹配目标
      }
    }

    // 如果没有匹配返回null
    return null;
  };
  _ctor.prototype.getNextTarget = function () {
    // 创建一个数组以存储目标类型
    const targetTypes = [];

    // 遍历目标并收集类型
    for (let index = 0; index < this.targets.length; index++) {
      const target = this.targets[index];
      targetTypes.push(target.type); // 保存目标类型
    }

    // 遍历数据并查找不在目标类型中的项
    for (let i = 0; i < this.data.length; i++) {
      const dataItem = this.data[i];
      if (!targetTypes.includes(dataItem)) {
        this.data.splice(i, 1); // 删除不匹配的数据项
        return dataItem; // 返回该数据项
      }
    }

    // 如果数据数组为空，返回-1
    if (this.data.length <= 0) {
      return -1;
    } else {
      return this.data.shift(); // 返回并移除数组的第一个项
    }
  };
  _ctor.prototype.setTargetWithTmpMore = function () {
    // 创建一个数组以存储临时节点的类型
    const temporaryTypes = [];

    // 遍历活动槽并收集类型
    for (let index = 0; index < this.tmpNodeMgr.activeSlotCount; index++) {
      const temporaryNode = this.tmpNodeMgr.tmpContents[index];
      if (temporaryNode) {
        temporaryTypes.push(temporaryNode.type); // 保存临时节点类型
      }
    }

    // 使用函数m处理类型数组
    const uniqueTypes = m(temporaryTypes);
    if (uniqueTypes.length <= 0) {
      return -1; // 如果没有唯一类型，返回-1
    }

    const firstType = uniqueTypes[0]; // 获取第一个唯一类型

    // 遍历数据并查找匹配项
    for (let index = 0; index < this.data.length; index++) {
      const dataItem = this.data[index];
      if (dataItem === firstType) {
        _(this.data, 0, index); // 执行某些操作（具体功能取决于_函数）
        return dataItem; // 返回匹配的数据项
      }
    }

    return -1; // 如果没有找到匹配项，返回-1
  };
  _ctor.prototype.setTargetWithTopBoard = function (t) {
    // 确保变量t已定义，默认值为2
    if (undefined === t) {
      t = 2;
    }

    // 获取最顶层对象并处理
    const topObjects = m(this.gamePlay.getTopObjs(t));
    if (topObjects.length <= 0) {
      return -1; // 如果没有顶层对象，返回-1
    }

    const firstObject = topObjects[0]; // 获取第一个顶层对象

    // 遍历数据并查找匹配项
    for (let index = 0; index < this.data.length; index++) {
      const dataItem = this.data[index];
      if (dataItem === firstObject) {
        _(this.data, 0, index); // 执行某些操作（具体功能取决于_函数）
        return dataItem; // 返回匹配的数据项
      }
    }

    return -1; // 如果没有找到匹配项，返回-1
  };
  _ctor.prototype.pushObjToTemp = function (t) {
    const context = this; // 保存当前上下文
    const emptyIndex = this.tmpNodeMgr.getEmptyIndex(); // 获取临时节点管理器中的空索引

    if (emptyIndex !== -1) {
      // 将对象推送到临时节点中
      const pushedObject = this.tmpNodeMgr.pushObjToTemp(t, emptyIndex);

      // 执行动作动画
      this.operateObjAnimation(t, pushedObject.node, () => {
        pushedObject.isAnimated = false; // 动画完成后设置为非动画状态
        context.checkTemporarySlot(); // 检查临时槽
        context.checkGameOver("onRemoveScrew"); // 检查游戏是否结束
      });
    }
  };
  _ctor.prototype.isTmpFull = function () {
    return this.tmpNodeMgr.isFull();
  };
  _ctor.prototype.isOrderAnimating = function () {
    // 遍历目标列表，查找状态为 Loading 的目标
    for (let index = 0; index < this.targets.length; index++) {
      const target = this.targets[index];
      if (target.state === p.default.TargetState.Loading) {
        return target; // 如果找到，返回该目标
      }
    }

    // 遍历目标列表，查找目标计数为 0 的目标
    for (let index = 0; index < this.targets.length; index++) {
      const target = this.targets[index];
      if (target.targetCount === 0) {
        return target; // 如果找到，返回该目标
      }
    }

    // 如果没有找到符合条件的目标，返回 null
    return null;
  };
  _ctor.prototype.checkGameOver = function (t) {
    cc.log("checkGameOver", t); // 输出当前状态

    if (this.isTmpFull()) {
      // 检查临时槽是否已满
      if (this.data.length > 0 && this.targets.length < this.unlockCount) {
        cc.log("还有未结束的目标"); // 输出有未完成目标的日志
      } else if (this.isOrderAnimating()) {
        cc.log("还有订单动画"); // 输出有动画正在进行的日志
      } else if (this.isAnyMatched()) {
        cc.log("还有匹配的"); // 输出还有匹配项的日志
      } else {
        this.feibiao.gameOver(); // 调用游戏结束函数
      }
    } else {
      cc.log("还有空槽"); // 输出有空槽的日志
    }
  };
  _ctor.prototype.onTouchOperateObj = function (t) {
    if (this.isTmpFull()) {
      // 如果临时槽已满，显示消息
      $zqcc_OverallSystem.sers().uiSrv.showMessage("槽位已满,无法继续放入");
    } else {
      // 查找匹配目标
      const matchingTarget = this.findMatchingTarget(t);
      if (matchingTarget) {
        // 如果找到匹配目标，填充订单
        this.fillOrder(t, matchingTarget);
      } else {
        // 否则，将对象推送到临时槽
        this.pushObjToTemp(t);
      }
    }
  };
  _ctor.prototype.canUnlock = function () {
    return this.unlockCount >= 4;
  };
  _ctor.prototype.onUnlock = function () {
    cc.log("onUnlock"); // 输出解锁事件日志

    // 检查解锁计数是否小于4
    if (this.unlockCount < 4) {
      const remainingUnlocks = 4 - this.unlockCount; // 计算剩余解锁数量
      this.targetsNode.getChildByName("unlock_" + remainingUnlocks).active = false; // 关闭对应的解锁节点

      // 设置目标和最大简单计数
      this.setTargetWithTmpMore();
      this.setEasyCountMax();

      // 获取下一个目标并处理生成
      const nextTarget = this.getNextTarget();
      if (nextTarget >= 0) {
        this.handleTargetGeneration(this.unlockCount, nextTarget);
      } else {
        cc.log("所有目标已经出完"); // 输出所有目标已完成的日志
      }

      // 播放解锁音效
      $zqcc_OverallSystem.mgrs().soundMgr.playSound("jiesuo");

      // 增加解锁计数
      this.unlockCount++;
    }
  };
  _ctor.prototype.onUnlockTmp = function () {
    this.tmpNodeMgr.onUnlockTmp();
  };
  _ctor.prototype.onRemoveBoard = function (t) {
    // 从目标节点中获取子节点并处理
    for (let index = t.objsNode.children.length - 1; index >= 0; index--) {
      const childComponent = t.objsNode.children[index].getComponent(u.default); // 获取子节点的组件
      childComponent.node.parent = null; // 移除子节点的父级
      this.tmpNodeMgr.pushToHideTmp(childComponent); // 将子节点推送到隐藏临时节点
    }

    // 检查临时槽
    this.checkTemporarySlot();
  };
  _ctor.prototype.onClearTmp = function () {
    const context = this; // 保存当前上下文

    // 安排一次延迟执行的任务
    this.scheduleOnce(() => {
      context.tmpNodeMgr.clearTmp(() => {
        context.setEasyCountMax(); // 设置最大简单计数
        $zqcc_OverallSystem.mgrs().soundMgr.playSound("dianji02"); // 播放点击音效
      });
    }, 0.5); // 延迟0.5秒执行
  };
  _ctor.prototype.canClear = function () {
    return this.tmpNodeMgr.canClear();
  };
  _ctor.prototype.setEasyCountMax = function () {
    // 根据飞标等级设置easyCount
    // 如果等级小于或等于8，设置easyCount为4
    // 否则，设置easyCount为2
    this.easyCount = this.feibiao.level <= 8 ? 4 : 2
  };
  _ctor.prototype.operateObjAnimation = function (t, e, o, n) {
    // 确保n已定义，默认值为20
    if (undefined === n) {
      n = 20;
    }

    // 停止目标的所有动画
    cc.Tween.stopAllByTarget(t.node);

    // 创建绳子节点
    const ropeNode = this.createRopeNode(t.node, t.type, n);

    // 将世界坐标转换为节点空间坐标
    const convertedPosition = this.convertToNodeSpaceAR(e, ropeNode.node);

    // 定义绳子的动画路径
    const animationPath = [
      cc.v3(convertedPosition.x - 20, convertedPosition.y, 0),
      cc.v3(convertedPosition.x, convertedPosition.y + 20, 0),
      cc.v3(convertedPosition.x, convertedPosition.y - 20, 0),
      cc.v3(convertedPosition.x + 10, convertedPosition.y + 20, 0),
      cc.v3(convertedPosition.x + 10, convertedPosition.y - 20, 0),
      cc.v3(convertedPosition.x + 20, convertedPosition.y + 20, 0),
      cc.v3(convertedPosition.x + 20, convertedPosition.y - 20, 0)
    ];

    // 处理绳子的动画
    this.handleRopeAnimation(animationPath, ropeNode);

    // 更新目标的状态
    t.removeFromBoard();
    t.node.position = ropeNode.node.position; // 设置目标的位置
    t.node.parent = this.levelRoot; // 设置目标的父节点
    t.node.zIndex = cc.macro.MAX_ZINDEX; // 设置放置顺序

    // 开始目标移动
    t.moveStart(() => {
      const soundEffectIndex = Math.floor(Math.random() * 3) + 1; // 随机选择音效索引
      $zqcc_OverallSystem.mgrs().soundMgr.playEffect("merge_" + soundEffectIndex, "Feibiao", false, 0.1); // 播放合并音效
      ropeNode.destroyByReset(); // 重置绳子节点
      t.node.parent = null; // 清除目标的父节点
      o(); // 调用回调函数
    });
  };
  cc__decorate([ccp_property(cc.Node)], _ctor.prototype, "targetsNode", undefined);
  cc__decorate([ccp_property(cc.Node)], _ctor.prototype, "levelRoot", undefined);
  cc__decorate([ccp_property(cc.Prefab)], _ctor.prototype, "targetPrefab", undefined);
  cc__decorate([ccp_property(cc.Prefab)], _ctor.prototype, "ropePrefab", undefined);
  cc__decorate([ccp_property(h.default)], _ctor.prototype, "tmpNodeMgr", undefined);
  cc__decorate([ccp_property(y.default)], _ctor.prototype, "paintBoard", undefined);
  cc__decorate([ccp_property(cc.ProgressBar)], _ctor.prototype, "progressBar", undefined);
  cc__decorate([ccp_property(cc.Label)], _ctor.prototype, "progressLabel", undefined);
  return cc__decorate([ccp_ccclass], _ctor);
}(cc.Component);
exports.default = def_TargetMgr;